package com.ffcs.crmd.tsp.client.netty;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import com.ffcs.crmd.tsp.api.netty.INettyConfigClient;
import com.ffcs.crmd.tsp.core.util.RemotingUtil;

/**
 * 
 * 功能说明:netty客户端通信配置
 *
 * @author ZHONGFUHUA
 * 
 * @since 1.0.0-SNAPSHOT
 *
 */
public class NettyConfig implements INettyConfigClient {
    
    /**
     * 本地IP地址
     */
    private final String clientIP                        = RemotingUtil.getLocalAddress();
    
    /**
     * 信号量，异步调用情况会使用，防止本地Netty缓存请求过多
     */
    private int          permitsOneway                   = 60000;
    
    /**
     * 信号量，Oneway情况会使用，防止本地Netty缓存请求过多
     */
    private int          permitsAsync                    = 60000;
    
    /**
     * netty服务器端口
     */
    private int          listenPort                      = 1314;
    
    /**
     * 发送缓冲器大小
     */
    private int          socketSndBufSize                = 131072;
    
    /**
     * 接收缓冲器大小
     */
    private int          socketRcvBufSize                = 131072;
    
    /**
     * 服务端处理请求线程池大小
     */
    private int          processorExecutorThreads        = 20;
    
    /**
     * 服务端回调线程池大小
     */
    private int          callbackExecutorThreads         = 5;
    
    /**
     * boss循环器线程数
     */
    private int          workGroupThreads                = 4;
    
    /**
     * futureChannel连接超时时间
     */
    private long         connectTimeoutMillis            = 10 * 1000;
    
    /**
     * 发送心跳间隔时间
     */
    private long         heartbeatBrokerInterval         = 30 * 1000;
    
    /**
     * 服务端IDLE事件超时时间
     */
    private int          clientChannelMaxIdleTimeSeconds = 120;
    
    /**
     * 服务端通信地址
     */
    private String       serverAddr;
    
    /**
     * 服务器地址数组
     */
    private List<String> serverAddrList                  = new ArrayList<String>();
    
    public NettyConfig(String serverAddr) {
        this.serverAddr = serverAddr;
        String[] addrList = this.serverAddr.split(";");
        for (String addr : addrList) {
            if (StringUtils.isNotBlank(addr)) {
                serverAddrList.add(addr);
            }
        }
    }
    
    public String buildClientId() {
        UUID uuid = UUID.randomUUID();
        String uuids = uuid.toString().replaceAll("-", "");
        StringBuilder sb = new StringBuilder();
        sb.append(this.getClientIP());
        
        sb.append("@");
        sb.append(uuids);
        
        return sb.toString();
    }
    
    /**
     * 功能说明: 获取信号量，异步调用情况会使用，防止本地Netty缓存请求过多
     *
     * @return permitsOneway 信号量，异步调用情况会使用，防止本地Netty缓存请求过多
     */
    @Override
    public int getPermitsOneway() {
        return permitsOneway;
    }
    
    /**
     * 功能说明: 设置信号量，异步调用情况会使用，防止本地Netty缓存请求过多
     *
     * @param permitsOneway 信号量，异步调用情况会使用，防止本地Netty缓存请求过多
     */
    @Override
    public void setPermitsOneway(int permitsOneway) {
        this.permitsOneway = permitsOneway;
    }
    
    /**
     * 功能说明: 获取信号量，Oneway情况会使用，防止本地Netty缓存请求过多
     *
     * @return permitsAsync 信号量，Oneway情况会使用，防止本地Netty缓存请求过多
     */
    @Override
    public int getPermitsAsync() {
        return permitsAsync;
    }
    
    /**
     * 功能说明: 设置信号量，Oneway情况会使用，防止本地Netty缓存请求过多
     *
     * @param permitsAsync 信号量，Oneway情况会使用，防止本地Netty缓存请求过多
     */
    @Override
    public void setPermitsAsync(int permitsAsync) {
        this.permitsAsync = permitsAsync;
    }
    
    /**
     * 功能说明: 获取netty服务器端口
     *
     * @return listenPort netty服务器端口
     */
    @Override
    public int getListenPort() {
        return listenPort;
    }
    
    /**
     * 功能说明: 设置netty服务器端口
     *
     * @param listenPort netty服务器端口
     */
    @Override
    public void setListenPort(int listenPort) {
        this.listenPort = listenPort;
    }
    
    /**
     * 功能说明: 获取发送缓冲器大小
     *
     * @return socketSndBufSize 发送缓冲器大小
     */
    @Override
    public int getSocketSndBufSize() {
        return socketSndBufSize;
    }
    
    /**
     * 功能说明: 设置发送缓冲器大小
     *
     * @param socketSndBufSize 发送缓冲器大小
     */
    @Override
    public void setSocketSndBufSize(int socketSndBufSize) {
        this.socketSndBufSize = socketSndBufSize;
    }
    
    /**
     * 功能说明: 获取接收缓冲器大小
     *
     * @return socketRcvBufSize 接收缓冲器大小
     */
    @Override
    public int getSocketRcvBufSize() {
        return socketRcvBufSize;
    }
    
    /**
     * 功能说明: 设置接收缓冲器大小
     *
     * @param socketRcvBufSize 接收缓冲器大小
     */
    @Override
    public void setSocketRcvBufSize(int socketRcvBufSize) {
        this.socketRcvBufSize = socketRcvBufSize;
    }
    
    /**
     * 功能说明: 获取服务端处理请求线程池大小
     *
     * @return processorExecutorThreads 服务端处理请求线程池大小
     */
    @Override
    public int getProcessorExecutorThreads() {
        return processorExecutorThreads;
    }
    
    /**
     * 功能说明: 设置服务端处理请求线程池大小
     *
     * @param processorExecutorThreads 服务端处理请求线程池大小
     */
    @Override
    public void setProcessorExecutorThreads(int processorExecutorThreads) {
        this.processorExecutorThreads = processorExecutorThreads;
    }
    
    /**
     * 功能说明: 获取服务端回调线程池大小
     *
     * @return callbackExecutorThreads 服务端回调线程池大小
     */
    @Override
    public int getCallbackExecutorThreads() {
        return callbackExecutorThreads;
    }
    
    /**
     * 功能说明: 设置服务端回调线程池大小
     *
     * @param callbackExecutorThreads 服务端回调线程池大小
     */
    @Override
    public void setCallbackExecutorThreads(int callbackExecutorThreads) {
        this.callbackExecutorThreads = callbackExecutorThreads;
    }
    
    /**
     * 功能说明: 获取boss循环器线程数
     *
     * @return workGroupThreads boss循环器线程数
     */
    @Override
    public int getWorkGroupThreads() {
        return workGroupThreads;
    }
    
    /**
     * 功能说明: 设置boss循环器线程数
     *
     * @param workGroupThreads boss循环器线程数
     */
    @Override
    public void setWorkGroupThreads(int workGroupThreads) {
        this.workGroupThreads = workGroupThreads;
    }
    
    /**
     * 功能说明: 设置futureChannel连接超时时间
     *
     * @param connectTimeoutMillis futureChannel连接超时时间
     */
    @Override
    public void setConnectTimeoutMillis(long connectTimeoutMillis) {
        this.connectTimeoutMillis = connectTimeoutMillis;
    }
    
    /**
     * 功能说明: 设置发送心跳间隔时间
     *
     * @param heartbeatBrokerInterval 发送心跳间隔时间
     */
    @Override
    public void setHeartbeatBrokerInterval(long heartbeatBrokerInterval) {
        this.heartbeatBrokerInterval = heartbeatBrokerInterval;
    }
    
    /**
     * 功能说明: 获取futureChannel连接超时时间
     *
     * @return connectTimeoutMillis futureChannel连接超时时间
     */
    @Override
    public long getConnectTimeoutMillis() {
        return connectTimeoutMillis;
    }
    
    /**
     * 功能说明: 获取发送心跳间隔时间
     *
     * @return heartbeatBrokerInterval 发送心跳间隔时间
     */
    @Override
    public long getHeartbeatBrokerInterval() {
        return heartbeatBrokerInterval;
    }
    
    /**
     * 功能说明: 获取本地IP地址
     *
     * @return clientIP 本地IP地址
     */
    public String getClientIP() {
        return clientIP;
    }
    
    /**
     * 功能说明: 获取服务端通信地址
     *
     * @return serverAddr 服务端通信地址
     */
    @Override
    public String getServerAddr() {
        return serverAddr;
    }
    

    
    /**
     * 功能说明: 获取服务端IDLE事件超时时间
     *
     * @return clientChannelMaxIdleTimeSeconds 服务端IDLE事件超时时间
     */
    public int getClientChannelMaxIdleTimeSeconds() {
        return clientChannelMaxIdleTimeSeconds;
    }
    

    /**
     * 功能说明: 设置服务端IDLE事件超时时间
     *
     * @param clientChannelMaxIdleTimeSeconds 服务端IDLE事件超时时间 
     */
    public void setClientChannelMaxIdleTimeSeconds(int clientChannelMaxIdleTimeSeconds) {
        this.clientChannelMaxIdleTimeSeconds = clientChannelMaxIdleTimeSeconds;
    }
    

    /**
     * 功能说明: 设置服务端通信地址
     *
     * @param serverAddr 服务端通信地址
     */
    @Override
    public void setServerAddr(String serverAddr) {
        this.serverAddr = serverAddr;
        serverAddrList.clear();
        String[] addrList = this.serverAddr.split(";");
        for (String addr : addrList) {
            if (StringUtils.isNotBlank(addr)) {
                serverAddrList.add(addr);
            }
        }
    }
    
    /**
     * 功能说明: 获取服务器地址数组
     *
     * @return serverAddrList 服务器地址数组
     */
    @Override
    public List<String> getServerAddrList() {
        return serverAddrList;
    }
    
}
